package com.cmic.rcs.emoji.util;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.util.Base64;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class AESUtils {

    // 加密算法模式
    public static final String AES_CBC = "AES/CBC/PKCS5Padding";

    // 加密秘钥
    @Value("${aes.key}:pXfIZ1nravvQpA7sSEthfLlr9xgnGzYs")
    private String KEY;

    // 初始向量
    @Value("${aes.iv}:0000000000000000")
    private String IV;

    // JSON处理对象
    private static final ObjectMapper objectMapper = new ObjectMapper();


    /**
     * 将对象转换为JSON字符串
     * @param obj 要转换的对象
     * @return 转换后的JSON字符串，对象为null时返回null
     */
    public static String objectToJson(Object obj) {
        if (obj == null) {
            return null;
        }
        try {
            return objectMapper.writeValueAsString(obj);
        } catch (JsonProcessingException e) {
            throw new RuntimeException("对象转JSON失败", e);
        }
    }

    /**
     * 将JSON字符串转换为指定类型的对象
     * @param json JSON字符串
     * @param clazz 目标对象类型
     * @param <T> 泛型类型
     * @return 转换后的对象，JSON为空时返回null
     */
    public static <T> T jsonToObject(String json, Class<T> clazz) {
        if (isEmpty(json)) {
            return null;
        }
        try {
            return objectMapper.readValue(json, clazz);
        } catch (Exception e) {
            throw new RuntimeException("JSON转对象失败", e);
        }
    }

    /**
     * 解密方法
     * @param text 加密文本
     * @param key AES密钥
     * @param iv IV向量
     * @return 解密后的明文
     */
    public static String decrypt(String text, String key, String iv){

        if (isEmpty(text) || isEmpty(key) || isEmpty(iv)) {
            return null;
        }

        // 将密文转换为16字节的密文字节数组
        byte[] textBytes = Base64.getDecoder().decode(text);

        try {
            // 创建AES加密器
            Cipher cipher = Cipher.getInstance(AES_CBC);

            SecretKeySpec secretKeySpec = getSecretKeySpec(key);

            cipher.init(Cipher.DECRYPT_MODE, secretKeySpec, new IvParameterSpec(getBytes(iv)));

            // 解密字节数组
            byte[] decryptedBytes = cipher.doFinal(textBytes);

            // 将明文转换为字符串
            return new String(decryptedBytes, StandardCharsets.UTF_8);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 加密方法
     * @param text 明文
     * @param key AES密钥
     * @param iv IV向量
     * @return 加密后的Base64字符串
     */
    public static String encrypt(String text, String key, String iv){
        if (isEmpty(text) || isEmpty(key) || isEmpty(iv)) {
            return null;
        }

        try {
            // 创建AES加密器
            Cipher cipher = Cipher.getInstance(AES_CBC);

            SecretKeySpec secretKeySpec = getSecretKeySpec(key);

            cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec, new IvParameterSpec(getBytes(iv)));

            // 加密字节数组
            byte[] encryptedBytes = cipher.doFinal(getBytes(text));

            // 将密文转换为 Base64 编码字符串
            return Base64.getEncoder().encodeToString(encryptedBytes);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 检查字符串是否为null或空字符串
     * @param str 待检查的字符串
     * @return 如果为null或空字符串返回true，否则返回false
     */
    private static boolean isEmpty(String str) {
        return str == null || str.trim().isEmpty();
    }

    public static SecretKeySpec getSecretKeySpec(String key){
        return new SecretKeySpec(getBytes(key), "AES");
    }

    public static byte[] getBytes(String str){
        if (isEmpty(str)){
            return null;
        }
        try{
            return str.getBytes(StandardCharsets.UTF_8);
        }catch (Exception e){
            throw new RuntimeException(e);
        }
    }
}